package nbcp.web.info

import io.swagger.annotations.Api
import io.swagger.annotations.ApiOperation
import nbcp.comm.JsonpMapping
import org.slf4j.LoggerFactory
import nbcp.base.comm.*
import nbcp.db.mongo.entity.SysUser
import org.springframework.web.bind.annotation.RestController
import nbcp.base.extend.*
import nbcp.base.utils.RecursionReturnEnum
import nbcp.base.utils.RecursionUtil
import nbcp.db.IdName
import nbcp.db.IdUrl
import nbcp.db.mongo.*
import nbcp.db.mongo.entity.MenuDefine
import nbcp.db.mongo.entity.SysLoginUser
import nbcp.web.UserId
import java.time.LocalDate
import javax.servlet.http.HttpServletRequest

/**
 * Created by udi on 17-3-31.
 */

@Api(description = "员工信息", tags = arrayOf("EmpInfo"))
@RestController
@JsonpMapping("/userInfo")
class UserInfo_Controller {

    companion object {
        private val logger = LoggerFactory.getLogger(this::class.java.declaringClass)
    }

    @ApiOperation(value = "查询员工列表")
    @JsonpMapping("/listUser")
    fun listUser(
            //            query: ListQueryModel,
            session: HttpServletRequest
    ): ListResult<SysUser> {

        var res = mor.system.sysUser.query(mor.system.sysUser.corp.id match session.Corp.id)
                .orderBy { it.id.asc }
                .toList()
        if (res.isEmpty()) {
            return ListResult("您还没有添加员工信息")
        }
        return ListResult(data = res)
    }

    @ApiOperation(value = "根据Id获取员工信息")
    @JsonpMapping("/getUser")
    fun getUser(
            userId: String,
            session: HttpServletRequest
    ): ApiResult<SysUser> {
        if (userId.isEmpty()) {
            logger.error("获取员工信息时，找不到用户ID，传递的userId信息为：" + userId)
            return ApiResult("找不到用户ID")
        }
//       var ret = mor.system.sysUser.findById(userId,mor.system.sysUser.corp.id match session.CorpId)
        var ret = mor.system.sysUser.query()
                .where(mor.system.sysUser.corp.id match session.Corp.id)
                .where(mor.system.sysUser.id match userId)
                .toEntity()
        return ApiResult.of(data = ret)
    }

    @ApiOperation(value = "新建员工信息")
    @JsonpMapping("/addUserInfo")
    fun addUserInfo(
            @JsonModel userInfo: SysUser,
            password: String, //初始密码
            session: HttpServletRequest
    ): ApiResult<SysUser> {
        var newUser = SysUser()
        if (userInfo.loginName.isEmpty()) {
            return ApiResult("登录名不能为空")
        }

        var CheckUser = mor.system.sysLoginUser.query(mor.system.sysLoginUser.loginName match userInfo.loginName).toEntity()
        if (CheckUser != null) {
            return ApiResult("登录名已存在，请更换其他用户名")
        }

        if (userInfo.name.isEmpty()) {
            return ApiResult("姓名不能为空")
        }

        var n = mor.system.sysUser.query(mor.system.sysUser.corp.id match session.Corp.id).count()
        if (n >= 6) {
            return ApiResult("您最多可添加5个用户")
        }
        newUser.corp.id = session.Corp.id
        newUser.corp.name = session.Corp.name
        newUser.loginName = userInfo.loginName
        newUser.name = userInfo.name

        newUser.email = userInfo.email
        newUser.sex = userInfo.sex
        newUser.mobile = userInfo.mobile

        mor.system.sysUser.insert(newUser)

//在SysLoginUser表里插入password等
        var sysLoginUser = SysLoginUser()
        sysLoginUser.id = newUser.id
        sysLoginUser.loginName = newUser.loginName
        sysLoginUser.password = password
        mor.system.sysLoginUser.insert(sysLoginUser)

        return ApiResult.of(data = newUser)
    }

    @ApiOperation(value = "更改员工信息，除logo,status,permissions")
    @JsonpMapping("/saveUserInfo")
    fun saveUserInfo(
            userId: String,
            name: String,
//            birthday: LocalDate?,
            email: String,
            sex: UserSexEnum?,
            mobile: String,
            qq: String,
            leader: Boolean?,
            password: String, //更改初始密码
            session: HttpServletRequest

    ): JsonResult {

        if (name.isEmpty()) {
            return JsonResult("姓名不能为空")
        }
/*
        if(mor.system.sysUser.query(mor.system.sysUser.loginName match loginName).toList().size > 0){
            return JsonResult("手机号已经被占用,请重试!")
        }*/

        mor.system.sysUser.update()
                .where(mor.system.sysUser.id match userId)
                .where(mor.system.sysUser.corp.id match session.Corp.id)
                .set(mor.system.sysUser.corp.toString(), session.Corp)
                .set(mor.system.sysUser.name, name)
//                .setIf(birthday != null, { it.birthday to birthday })
                .set(mor.system.sysUser.email, email)
                .set(mor.system.sysUser.sex, sex)
                .set(mor.system.sysUser.mobile, mobile)
                .exec()

        if (mor.affectRowCount == 0) {
            return JsonResult("更改失败")
        }

        if (password.HasValue) {
            var update = mor.system.sysLoginUser.updateById(userId)
                    .set(mor.system.sysLoginUser.password, if (password.HasValue) password else null)
            update.exec();

            if (mor.affectRowCount == 0) {
                return JsonResult("更改失败")
            }
        }



        return JsonResult()
    }

    @ApiOperation("重置密码")
    @JsonpMapping("/resetPassword")
    fun resetPassword(
            userId: String,
            session: HttpServletRequest
    ): JsonResult {
        val passwd = "123456"

        var Muser = mor.system.sysUser.query(mor.system.sysUser.corp.id match session.Corp.id).toEntity()

        if (Muser == null) {
            return JsonResult("沒有查找到用户")
        }

        var n = mor.system.sysLoginUser.updateById(userId)
                .set(mor.system.sysLoginUser.password, passwd)
                .exec()
        if (n != 1) {
            return JsonResult("重置密码失败，请稍后再试")
        }
        return JsonResult()
    }


    //根据_id更改logo或删除logo（IdUrl置为空）
    @ApiOperation("仅仅修改logo时使用此Api")
    @JsonpMapping("/setUserLogo")
    fun setUserLogo(
            userId: String,
            id: String,
            url: String,
            session: HttpServletRequest): JsonResult {

        if (userId.isEmpty()) {
            return JsonResult("userId参数不能为空")
        }
        val n = mor.system.sysUser.updateById(userId)
                .where(mor.system.sysUser.corp.id match session.Corp.id)
                .set(mor.system.sysUser.logo.toString(), IdUrl(id, url))
                .exec()

        if (n != 1) {
            return JsonResult(msg = "更改失败")
        }
        return JsonResult()
    }

//    @ApiOperation(value = "设置员工状态")
//    @JsonpMapping("/setStatus")
//    fun get(userId: String, status: UserStatusEnum, session: HttpServletRequest): JsonResult {
//        if (userId.isEmpty()) {
//            logger.error("设置员工状态时，找不到用户ID，传递的userId信息为：" + userId)
//            return JsonResult("找不到员工ID")
//        }
//
//        mor.system.sysUser.updateById(userId)
//                .where(mor.system.sysUser.corp.id match session.CorpId)
//                .set(mor.system.sysUser.status, status)
//                .exec();
//
//        if (mor.affectRowCount != 1) {
//            return JsonResult("设置状态失败")
//        }
//
//        if (status == UserStatusEnum.Quit) {
//            mor.system.sysLoginUser.updateById(userId)
//                    .set(mor.system.sysLoginUser.locked, true)
//                    .set(mor.system.sysLoginUser.lockedRemark, "已离职")
//                    .exec()
//        }
//
//        return JsonResult()
//    }

//    @ApiOperation(value = "设置员工角色关系")
//    @JsonpMapping("/setUserPermissions")
//    fun setUserPermissions(
//            userId: String,
//            @ApiParam("表示角色Id的数组") permissions: Array<String>,
//            session: HttpServletRequest
//    ): JsonResult {
//        if (userId.isEmpty()) {
//            logger.error("设置员工角色关系时，找不到员工ID，传递的userId信息为：" + userId)
//            return JsonResult("找不到员工ID")
//        }
//
//        var n = mor.system.sysUser.updateById(userId)
//                .where(mor.system.sysUser.corp.id match session.CorpId)
//                .set(mor.system.sysUser.permissions, permissions)
//                .exec()
//        if (n != 1) {
//            return JsonResult(msg = "更改失败")
//        }
//        return JsonResult()
//    }

//    @ApiOperation(value = "获取企业menus")
//    @JsonpMapping("/getCorpMenus")
//    fun getCorpMenus(
//            session: HttpServletRequest
//    ): ApiResult<Array<MenuDefine>> {
//        var ret = ApiResult<Array<MenuDefine>>();
//
//        var corpMenus = mor.system.sysCorporation.query()
//                .where(mor.system.sysCorporation.id match session.CorpId)
//                .select(mor.system.sysCorporation.menus)
//                .toEntity()!!.menus;
//
//        var sysDef = mor.system.sysCorporationDefinition.query()
//                .where(mor.system.sysCorporationDefinition.corpRole match CorpRoleEnum.Shop)
//                .toEntity()!!;
//
//        RecursionUtil.execute(sysDef.menus, { it.subMenus }) { it, parent, index ->
//            if (it.code.IsIn(*corpMenus.toTypedArray())) {
//                RecursionReturnEnum.Go
//            } else RecursionReturnEnum.Remove
//        }
//
//        ret.data = sysDef.menus.toTypedArray()
//
//        return ret;
//    }

//    @ApiOperation(value = "获取员工menus")
//    @JsonpMapping("/getUserMenus")
//    fun getUserMenus(
//            userId: String,
//            session: HttpServletRequest
//    ): ApiResult<Array<String>> {
//        var ret = ApiResult<Array<String>>();
//        if (userId.isEmpty()) {
//            ret.msg = "找不到员工ID";
//            return ret;
//        }
//
//        var myMenus = mor.system.sysUser.queryById(userId)
//                .select(mor.system.sysUser.menus)
//                .toEntity()!!.menus;
//
//        ret.data = myMenus.toTypedArray()
//
//        return ret;
//    }

//    @ApiOperation(value = "设置员工menus")
//    @JsonpMapping("/setUserMenus")
//    fun setUserMenus(
//            userId: String,
//            menus: Array<String>,
//            session: HttpServletRequest
//    ): JsonResult {
//        if (userId.isEmpty()) {
//            return JsonResult("找不到员工ID")
//        }
//
//        if (mor.system.sysUser.queryById(userId).toEntity()!!.admin) {
//            return JsonResult("管理员权限不能修改")
//        }
//
//        var corpInfo = mor.system.sysCorporation.queryById(session.CorpId).toEntity()!!;
//
//        mor.system.sysUser.updateById(userId)
//                .where(mor.system.sysUser.corp.id match session.CorpId)
//                .set(mor.system.sysUser.menus, menus)
//                .exec()
//        if (mor.affectRowCount == 0) {
//            return JsonResult(msg = "更改失败")
//        }
//        return JsonResult()
//    }

    @ApiOperation(value = "验证登录密码是否正确")
    @JsonpMapping("/checkPasswd")
    fun checkPasswd(
            oldPassword: String,
            session: HttpServletRequest
    ): JsonResult {
        var user = mor.system.sysLoginUser.queryById(session.UserId)
                .where(mor.system.sysLoginUser.password match oldPassword)
                .toEntity()
        if (user == null) {
            return JsonResult("您输入的密码有误，请重试")
        }
        return JsonResult()
    }

    @ApiOperation(value = "修改登录密码")
    @JsonpMapping("/changePasswd")
    fun changePasswd(
            oldPassword: String,
            newPassword: String,
            session: HttpServletRequest
    ): JsonResult {
        mor.system.sysLoginUser.updateById(session.UserId)
                .where(mor.system.sysLoginUser.password match oldPassword)
                .set(mor.system.sysLoginUser.password, newPassword)
                .exec()
        if (mor.affectRowCount == 0) {
            return JsonResult("更改密码失败")
        }
        return JsonResult()
    }


//    @ApiOperation(value = "设置溯源权限")
//    @JsonpMapping("/setUserTrackPermissions")
//    fun setUserTrackPermissions(
//            userId: String,
//            @ApiParam("溯源权限:上下内外") permissions: Array<Int>,
//            session: HttpServletRequest
//    ): JsonResult {
//        if (userId.isEmpty()) {
//            logger.error("设置溯源权限时，找不到员工ID，传递的userId信息为：" + userId)
//            return JsonResult("找不到员工ID")
//        }
//
//        var n = mor.system.sysUser.updateById(userId)
//                .where(mor.system.sysUser.corp.id match session.CorpId)
//                .set(mor.system.sysUser.trackPermission, permissions.sum())
//                .exec()
//        if (n != 1) {
//            return JsonResult(msg = "更改失败")
//        }
//
//        return JsonResult()
//    }


    @ApiOperation(value = "获取我的资料")
    @JsonpMapping("/getMyData")
    fun getMyData(session: HttpServletRequest): ApiResult<SysUser> {
        val ret = mor.system.sysUser.query()
                .where(mor.system.sysUser.corp.id match session.Corp.id)
                .where(mor.system.sysUser.id match session.UserId)
                .toEntity()
        return ApiResult.of(data = ret)
    }

    @ApiOperation(value = "更我的信息，除logo,status,permissions")
    @JsonpMapping("/saveMyData")
    fun saveMyData(
            loginName: String,
            name: String,

            birthday: LocalDate?,
            idCardNumber: String?,
            email: String?,
            sex: UserSexEnum?,
            mobile: String?,
            qq: String?,
            leader: Boolean?,
            deptName: String?,
            password: String?, //更改初始密码
            session: HttpServletRequest
    ): JsonResult {
        if (loginName.isEmpty()) {
            return JsonResult("登录名不能为空")
        }

        if (name.isEmpty()) {
            return JsonResult("姓名不能为空")
        }

        if (mor.system.sysUser.query(mor.system.sysUser.loginName match loginName).toList().size > 0) {
            return JsonResult("手机号已经被占用,请重试!")
        }
        mor.system.sysUser.update()
                .where(mor.system.sysUser.id match session.UserId)
                .where(mor.system.sysUser.corp.id match session.Corp.id)
                .set(mor.system.sysUser.corp.toString(), session.Corp)
                .set(mor.system.sysUser.loginName, loginName)
                .set(mor.system.sysUser.name, name)
                .set(mor.system.sysUser.birthday, birthday)
                .set(mor.system.sysUser.email, email)
                .set(mor.system.sysUser.sex, sex)
                .set(mor.system.sysUser.mobile, mobile)
                .exec()

        mor.system.sysLoginUser.update()
                .where(mor.system.sysLoginUser.id match session.UserId)
                .set(mor.system.sysLoginUser.loginName, loginName)
                .setIf(password.HasValue, { it.password to password })
                .exec()

        if (mor.affectRowCount == 1) {
            return JsonResult()
        }

        return JsonResult("更改失败")
    }


}